"""
summary: 
    Use the UIKit framework to construct and manage your application's 
    user interface for a device. This Objective-C framework provides 
    an application object, event handling, drawing model, windows, views, 
    and controls specifically designed for the Multi-Touch interface.
    
license: 
    M.I.T.
    
notes: 
    This module is a wrapper around the Cocoa UIKit
    The summaries for every class within this module are shamelessly copied from the corresponding
    reference webpage from Apple. I take no credit for them and they are only to provide a quick
    overview for the classes implemented. All credits for these summaries go out to Apple!
    
see: 
    http://developer.apple.com/iphone/library/navigation/Frameworks/CocoaTouch/UIKit/index.html
    http://developer.apple.com/DOCUMENTATION/Cocoa/Conceptual/CocoaFundamentals/Art/uikit_classes.jpg
    
since: 
    20.03.2009

version: 
    0.0.3
"""

import new

#Create module to hold the Objective-C objects
__internalObjects__ = new.module("__internalObjects__")

try:
    #Import Objective C
    import objc
        
    #Load Objective-C Objects into python library "__internalObjects__".    
    objc.loadBundle("UIKit", __internalObjects__.__dict__, "/System/Library/Frameworks/UIKit.framework")
    
except ImportError: 
    print "No Python Objective C library installed on this system!"

#Init __all__
__all__ = ["UIResponder",
           "UITouch",
           "UIEvent",
           "UIFont",
           "UIColor",
           "UIImage",
           "UIScreen",
           "UINavigationItem",
           "UIBarItem",
           "UIViewController",
           "UIDevice",
           "UIAccelerometer",
           "UIAcceleration",
           "UIApplication",
           "UIView",
           "UITabBarItem",
           "UIBarButtonItem",
           "UITabBarController",
           "UITableViewController",
           "UINavigationController",
           "UIWindow",
           "UILabel",
           "UIPickerView",
           "UIProgressView",
           "UIActivityIndicatorView",
           "UIImageView",
           "UITabBar",
           "UIToolbar",
           "UINavigationBar",
           "UITableViewCell",
           "UIActionSheet",
           "UIAlertView",
           "UIScrollView",
           "UISearchBar",
           "UIWebView",
           "UIControl",
           "UIImagePickerController",
           "UITableView",
           "UITextView",
           "UIButton",
           "UIDatePicker",
           "UIPageControl",
           "UISegmentedControl",
           "UITextField",
           "UISlider",
           "UISwitch"]

class NSObject:
    """
    summary:
        NSObject is the root class of most Objective-C class hierarchies. Through NSObject, objects 
        inherit a basic interface to the runtime system and the ability to behave as Objective-C objects.
        
    see:
        http://developer.apple.com/iphone/library/documentation/Cocoa/Reference/Foundation/Classes/NSObject_Class/Reference/Reference.html#//apple_ref/occ/cl/NSObject
    """
    
    def __init__(self):
        """
        summary:
            Initializes the object. It creates the base variable to hold the Objective-C object to wrap.
        """
        self.__internalObject__ = None

class UIResponder(NSObject):
    """
    summary:
        The UIResponder class defines an interface for objects that respond to and handle events. It is the superclass 
        of UIApplication, UIView and its subclasses (which include UIWindow). Instances of these classes are sometimes 
        referred to as responder objects.

        The primary event-handling methods are touchesBegan:withEvent:, touchesMoved:withEvent:, touchesEnded:withEvent:, 
        and touchesCancelled:withEvent:. The parameters of these methods associate touches with their events -especially 
        touches that are new or have changed- and thus allow responder objects to track and handle the touches as the 
        delivered events progress through the phases of a multi-touch sequence. Any time a finger touches the screen, 
        is dragged on the screen, or lifts from the screen, a UIEvent object is generated. The event object contains 
        UITouch objects for all fingers on the screen or just lifted from it. 

        See Event Handling in iPhone Application Programming Guide for further information on event handling. 
        
    see:
        http://developer.apple.com/iphone/library/documentation/UIKit/Reference/UIResponder_Class/Reference/Reference.html
    """
    def __init__(self):
        #Initialize Super Class
        NSObject.__init__(self)

class UITouch(NSObject):
    """
    summary:
        A UITouch object represents the presence or movement of a finger on the screen for a particular event. You access 
        UITouch objects through UIEvent objects passed into responder objects for event handling.

        A UITouch object includes methods for accessing the view or window in which the touch occurred and for 
        obtaining the location of the touch in a specific view or window. it also lets you find out when the touch 
        occurred, whether the user tapped more than once, whether the finger is swiped (and if so, in which direction), 
        and the phase of a touch-that is, whether it began, moved, or ended the gesture, or whether it was canceled. 

        A UITouch object is persistent throughout a multi-touch sequence. You should never retain an UITouch object 
        when handling an event. If you need to keep information about a touch from one phase to another, you should 
        copy that information from the UITouch object.

        See Event Handling in iPhone Application Programming Guide for further information on event handling. 
        
    see:
        http://developer.apple.com/iphone/library/documentation/UIKit/Reference/UITouch_Class/Reference/Reference.html
    """
    def __init__(self):
        #Initialize Super Class
        NSObject.__init__(self)

class UIEvent(NSObject):
    """
    summary:
        A UIEvent object (or, simply, an event object) represents an event in iPhone OS. An event object contains one or 
        more touches (that is, finger gestures on the screen) that have some relation to the event. A touch is 
        represented by a UITouch object.

        When an event occurs, the system routes it to the appropriate responder and passes in the UIEvent object in 
        a message invoking a UIResponder method such as touchesBegan:withEvent:. The responder can then evaluate the 
        touches for the event or for a particular phase of the event and handle them appropriately. The methods of 
        UIEvent allow you to obtain all touches for the event (allTouches) or only those for a given view or window 
        (touchesForView: or touchesForWindow:). It can also distinguish an event object from objects representing other 
        events by querying an object for the time of its creation (timestamp).

        A UIEvent object is persistent throughout a multi-touch sequence; UIKit reuses the same UIEvent instance for 
        every event delivered to the application. You should never retain an event object or any object returned from 
        an event object. If you need to keep information from an event around from one phase to another, you should 
        copy that information from the UITouch or UIEvent object.

        See "Event Handling" in iPhone Application Programming Guide for further information on event handling. 

    see:
        http://developer.apple.com/iphone/library/documentation/UIKit/Reference/UIEvent_Class/Reference/Reference.html
    """
    def __init__(self):
        #Initialize Super Class
        NSObject.__init__(self)

class UIFont(NSObject):
    """
    summary:
        The UIFont class provides the interface for getting and setting font information. The class provides you with 
        access to the font\'s characteristics and also provides the system with access to the font\'s glyph information, 
        which is used during layout. You use font objects by passing them to methods that accept them as a parameter. 

        You do not create UIFont objects using the alloc and init methods. Instead, you use class methods of UIFont to 
        look up and retrieve the desired font object. These methods check for an existing font object with the specified 
        characteristics and return it if it exists. Otherwise, they create a new font object based on the desired font 
        characteristics.

    see:
        http://developer.apple.com/iphone/library/documentation/UIKit/Reference/UIFont_Class/Reference/Reference.html
    """
    def __init__(self):
        #Initialize Super Class
        NSObject.__init__(self)

class UIColor(NSObject):
    """
    summary:
        A UIColor object represents color and sometimes opacity (alpha value). You can use UIColor objects to store 
        color data, and during drawing you can use them to set the current fill and stroke colors. 

        Many methods in UIKit require you to specify color data using a UIColor object, and for general color needs 
        it should be your main way of specifying colors. The color spaces used by this object are optimized for use on 
        iPhone OS-based devices and are therefore appropriate for most drawing needs. If you prefer to use Core 
        Graphics colors and color spaces instead, however, you may do so.

        Most developers should have no need to subclass UIColor. The only time doing so might be necessary is if you 
        require support for additional colorspaces or color models.
        
    see:
        http://developer.apple.com/iphone/library/documentation/UIKit/Reference/UIColor_Class/Reference/Reference.html
    """
    def __init__(self):
        #Initialize Super Class
        NSObject.__init__(self)

class UIImage(NSObject):
    """
    summary:
        A UIImage object is a high-level way to display image data. You can create images from files, from Quartz image 
        objects, or from raw image data you receive. The UIImage class also offers several options for drawing images to 
        the current graphics context using different blend modes and opacity values.

        Image objects are immutable, so you cannot change their properties after creation. This means that you generally 
        specify an image\'s properties at initialization time or rely on the image\'s metadata to provide the property 
        value. In some cases, however, the UIImage class provides convenience methods for obtaining a copy of the image 
        that uses custom values for a property. 

        Because image objects are immutable, they also do not provide direct access to their underlying image data. 
        However, you can get an NSData object containing either a PNG or JPEG representation of the image data using 
        the UIImagePNGRepresentation and UIImageJPEGRepresentation functions.

    see:
        http://developer.apple.com/iphone/library/documentation/UIKit/Reference/UIImageView_Class/Reference/Reference.html
    """
    def __init__(self):
        #Initialize Super Class
        NSObject.__init__(self)

class UIScreen(NSObject):
    """
    summary:
        A UIScreen object contains the bounding rectangle of the device\'s entire screen. When setting up your 
        application\'s user interface, you should use the properties of this object to get the recommended frame 
        rectangles for your application\'s window.

    see:
        http://developer.apple.com/iphone/library/documentation/UIKit/Reference/UIScreen_Class/Reference/UIScreen.html
    """
    def __init__(self):
        #Initialize Super Class
        NSObject.__init__(self)

class UINavigationItem(NSObject):
    """
    summary:
        The UINavigationItem class encapsulates information about a navigation item pushed on a UINavigationBar object\'s 
        stack. A navigation bar is a control used to navigate hierarchical content. A UINavigationItem specifies what is 
        displayed on the navigation bar when it is the top item and also how it is represented when it is the back item.

        Use the initWithTitle: method to create a navigation item specifying the item\'s title. The item cannot be 
        represented on the navigation bar without a title. Use the backBarButtonItem property if you want to use a 
        different title when this item is the back item. The backBarButtonItem property is displayed as the back button 
        unless a custom left view is specified.

        The navigation bar displays a back button on the left and the title in the center by default. You can change 
        this behavior by specifying either a custom left, center, or right view. Use the s
        etLeftBarButtonItem:animated: and setRightBarButtonItem:animated: methods to change the left and right views; 
        you can specify that the change be animated. Use the titleView method to change the center view to a custom view.

        These custom views can be system buttons. Use the UIBarButtonItem class to create custom views to add to 
        navigation items.

    see:
        http://developer.apple.com/iphone/library/documentation/UIKit/Reference/UINavigationItem_Class/Reference/UINavigationItem.html
    """
    def __init__(self):
        #Initialize Super Class
        NSObject.__init__(self)

class UIBarItem(NSObject):
    """
    summary:
        UIBarItem is an abstract superclass for items added to a bar that appears at the bottom of the screen. 
        Items on a bar behave in a way similar to buttons. They have a title, image, action, and target. You can also 
        enable and disable an item on a bar.

    see:
        http://developer.apple.com/iphone/library/documentation/UIKit/Reference/UIBarItem_Class/Reference/Reference.html
    """
    def __init__(self):
        #Initialize Super Class
        NSObject.__init__(self)

class UIViewController(NSObject):
    """
    summary:
        The UIViewController class provides the fundamental view-management model for iPhone. You use instances of 
        UIViewController, and its subclasses, to manage tab bars, navigation bars, and the application views you want 
        displayed when items are selected. The UIViewController class also supports modal views and rotating views when 
        the orientation changes.

        The UIViewController class is a superclass for all controllers that manage a full-screen view. For example, 
        a tab bar controller manages a tab bar and the view above it used to implement radio interfaces-clicking on tab 
        bar buttons toggles the view above the tab bar. A navigation controller manages a navigation bar and the view 
        below it used to navigate hierarchically. These specialized view controllers hide the complexity of using the 
        UITabBar and UINavigationBar classes directly.

        You primarily subclass the UIViewController class to create your own custom view controllers that manage your 
        full-screen views. You can create a single view controller and add its view to a window just for the benefit 
        of autorotation. Or add the view controller to a tab bar controller or navigation controller and let those 
        objects manage your full-screen views. What methods you use to configure your view controller depends on how 
        you plan to use it.

        All subclasses of UIViewController should implement the loadView method to set the view property unless you 
        load your view from a nib file. The view you create should be a normal view that can be added to any view 
        hierarchy and resized by the controller. When a view controller is added to a tab bar or navigation controller, 
        its view is resized to fit the available space between the tab bar and navigation bar if they are present. 
        Use the autoresizesSubviews and autoresizingMask properties so that your view and its subviews autoresize 
        gracefully. You\'ll need these properties set to autoresize when the orientation changes too.

        A view controller pushed onto the stack of a navigation controller should also set some of the properties in 
        'Configuring Navigation Items' to configure a navigation bar when the view controller is the top view controller. 
        Specifically, use the navigationItem property to configure the navigation bar. Read UINavigationController 
        Class Reference for details.

        Similarly, a view controller that is added to a tab bar controller should set the tabBarItem property used to 
        update the tab bar when the view controller is selected. Read UITabBarController Class Reference before using 
        the 'Configuring Tab Bar Items' methods.

        View controllers also support autorotation-they slide the tab bar and navigation bar out before the interface 
        rotates, and slide them in after the interface rotates. You can optionally augment the animation and even 
        replace the view for different orientations-for example, use a different view for portrait than for landscape 
        orientation. If your view controller supports orientations other than portrait, override the 
        shouldAutorotateToInterfaceOrientation: method to return YES for the orientations it supports.

        View controllers are inserted after their views in the responder chain. That is, a view controller can optionally 
        handle an event that its view does not handle. A view controller\'s next responder is its view\'s superview.

    see:
        http://developer.apple.com/iphone/library/documentation/UIKit/Reference/UIViewController_Class/Reference/Reference.html
    """
    def __init__(self):
        #Initialize Super Class
        NSObject.__init__(self)

class UIDevice(NSObject):
    """
    summary:
        The UIDevice class vends a singleton instance representing the current device. From this instance you can obtain 
        information about the device, such as unique ID, assigned name, device model, and operating-system name and 
        version.

        You can also use the UIDevice class to detect changes in the device\'s physical orientation. You can get the 
        current orientation using the orientation property or receive change notifications by registering for the 
        UIDeviceOrientationDidChangeNotification notification. Before using either of these techniques to get orientation 
        data, you must enable the delivery of the data using the beginGeneratingDeviceOrientationNotifications method. 
        When you no longer need to track the device orientation, you should similarly use the 
        endGeneratingDeviceOrientationNotifications method to disable the delivery of notifications. 

    see:
        http://developer.apple.com/iphone/library/documentation/UIKit/Reference/UIDevice_Class/Reference/UIDevice.html
    """
    def __init__(self):
        #Initialize Super Class
        NSObject.__init__(self)

class UIAccelerometer(NSObject):
    """
    summary:
        The UIAccelerometer class lets you register to receive acceleration-related data from the onboard hardware. As a 
        device moves, its hardware reports linear acceleration changes along the primary axes in three-dimensional space. 
        You can use this data to detect both the current orientation of the device (relative to the ground) and any 
        instantaneous changes to that orientation. You might use instantaneous changes as input to a game or to initiate 
        some action in your application. 

        You do not create accelerometer objects directly. Instead, you use the shared UIAccelerometer object to specify 
        the interval at which you want to receive events and then set its delegate property. Upon assigning your delegate 
        object, the accelerometer object begins delivering acceleration events to your delegate immediately at the 
        specified interval. Events are always delivered on the main thread of your application.

        The maximum frequency for accelerometer updates is based on the available hardware. You can request updates less 
        frequently but cannot request them more frequently than the hardware maximum. Once you assign your delegate, 
        however, updates are delivered regularly at the frequency you requested, whether or not the acceleration data 
        actually changed. Your delegate is responsible for filtering out any unwanted updates and for ensuring that the 
        amount of change is significant enough to warrant taking action.

        For more information about the data delivered to your observer, see UIAcceleration Class Reference. For information 
        about implementing your delegate object, see UIAccelerometerDelegate Protocol Reference. 

    see:
        http://developer.apple.com/iphone/library/documentation/UIKit/Reference/UIAccelerometer_Class/Reference/UIAccelerometer.html
    """
    def __init__(self):
        #Initialize Super Class
        NSObject.__init__(self)

class UIAcceleration(NSObject):
    """
    summary:
        The UIAcceleration class stores the data associated with an acceleration event. When your application receives an 
        accelerometer notification, an instance of this class is stored in the object field of the notification. 
        For information on how to receive accelerometer notifications, see UIAccelerometer class. 

        Each acceleration event relays the current acceleration readings along the three axes of the device. Acceleration 
        values for each axis are reported directly by the hardware as G-force values. Therefore, a value of 1.0 
        represents a load of about +1g along a given axis while a value of -1.0 represents -1g. 

    see:
        http://developer.apple.com/iphone/library/documentation/UIKit/Reference/UIAcceleration_Class/Reference/UIAcceleration.html
    """
    def __init__(self):
        #Initialize Super Class
        NSObject.__init__(self)

class UIApplication(UIResponder):
    """
    summary:
        The UIApplication class provides a centralized point of control and coordination for applications running on 
        iPhone OS.

        Every application must have exactly one instance of UIApplication (or a subclass of UIApplication ). When an 
        application is launched, the UIApplicationMain function is called; among its other tasks, this function create a 
        singleton UIApplication object. Thereafter you can access this object by invoking the sharedApplication class 
        method.

        A major role of a UIApplication object is to handle the initial routing of incoming user events. It also 
        dispatches action messages forwarded to it by control objects (UIControl) to the appropriate target objects. 
        In addition, the UIApplication object maintains a list of all the windows (UIWindow objects) currently open in 
        the application, so through those it can retrieve any of the application\'s UIView objects. The application 
        object is typically assigned a delegate, an object that the application informs of significant runtime 
        events-for example, application launch, low-memory warnings, and application termination-giving it an 
        opportunity to respond appropriately.

        Applications can cooperatively handle a resource such as an email or an image file through the openURL: method. 
        For example, an application opening an email URL with this method may cause the mail client to launch and 
        display the message.

        UIApplication defines a delegate that must adopt the UIApplicationDelegate protocol implement one or more of 
        the methods.

        The programmatic interfaces of UIApplication and UIApplicationDelegate also allow you to manage behavior that 
        is specific to the device. You can control application response to changes in interface orientation, temporarily 
        suspend incoming user events, and turn proximity sensing (of the user\'s face) off and on again. 

    see:
        http://developer.apple.com/iphone/library/documentation/UIKit/Reference/UIApplication_Class/Reference/Reference.html
    """
    def __init__(self):
        #Initialize Super Class
        UIResponder.__init__(self)

class UIView(UIResponder):
    """
    summary:
        The UIView class is primarily an abstract superclass that provides concrete subclasses with a structure for drawing 
        and handling events. You can also create instances of UIView to contain other views.

        UIView objects are arranged within an UIWindow object, in a nested hierarchy of subviews. Parent objects in the 
        view hierarchy are called superviews, and children are called subviews. A view object claims a rectangular region 
        of its enclosing superview, is responsible for all drawing within that region, and is eligible to receive events 
        occurring in it as well. Sibling views are able to overlap without any issues, allowing complex view placement.

        The UIView class provides common methods you use to create all types of views and access their properties. For 
        example, unless a subclass has its own designated initializer, you use the initWithFrame: method to create a view. 
        The frame property specifies the origin and size of a view in superview coordinates. The origin of the coordinate 
        system for all views is in the upper-left corner. 

        You can also use the center and bounds properties to set the position and size of a view. The center property 
        specifies the view\'s center point in superview\'s coordinates. The bounds property specifies the origin in the 
        view\'s coordinates and its size (the view\'s content may be larger than the bounds size). The frame property is 
        actually computed based on the center and bounds property values. Therefore, you can set any of these three 
        properties and they affect the values of the others.

        It\'s important to set the autoresizing properties of views so that when they are displayed or the orientation 
        changes, the views are displayed correctly within the superview\'s bounds. Use the autoresizesSubviews property, 
        especially if you subclass UIView, to specify whether the view should automatically resize its subviews. Use the 
        autoresizingMask property with the constants described in UIViewAutoresizing to specify how a view should 
        automatically resize.

        The UIView class provides a number of methods for managing the view hierarchy. Use the superview property to get 
        the parent view and the subviews property to get the child views in the hierarchy. There are also a number of        
        
        methods, listed in \"Managing the View Hierarchy\" for adding, inserting, and removing subviews as well as arranging 
        subviews in front of or in back of siblings.

        When you subclass UIView to create a custom class that draws itself, implement the drawRect: method to draw the 
        view within the specified region. This method is invoked the first time a view displays or when an event occurs 
        that invalidates a part of the view's frame requiring it to redraw its content. 

        Normal geometry changes do not require redrawing the view. Therefore, if you alter the appearance of a view and 
        want to force it to redraw, send setNeedsDisplay or setNeedsDisplayInRect: to the view. You can also set the 
        contentMode to UIViewContentModeRedraw to invoke the drawRect: method when the bounds change; otherwise, the view 
        is scaled and clipped without redrawing the content. 

        Subclasses can also be containers for other views. In this case, just override the designated initializer, 
        initWithFrame:, to create a view hierarchy. If you want to programmatically force the layout of subviews before 
        drawing, send setNeedsLayout to the view. Then when layoutIfNeeded is invoked, the layoutSubviews method is 
        invoked just before displaying. Subclasses should override layoutSubviews to perform any custom arrangement of 
        subviews.

        Some of the property changes to view objects can be animated-for example, setting the frame, bounds, center, and 
        transform properties. If you change these properties in an animation block, the changes from the current state to 
        the new state are animated. Invoke the beginAnimations:context: class method to begin an animation block, set the 
        properties you want animated, and then invoke the commitAnimations class method to end an animation block. The 
        animations are run in a separate thread and begin when the application returns to the run loop. Other animation 
        class methods allow you to control the start time, duration, delay, and curve of the animations within the block.

        Use the hitTest:withEvent: and pointInside:withEvent: methods if you are processing events and want to know where 
        they occur. The UIView class inherits other event processing methods from UIResponder. For more information on how 
        views handle events, read UIResponder Class Reference.
        
    see:
        http://developer.apple.com/iphone/library/documentation/UIKit/Reference/UIView_Class/UIView/UIView.html
    """
    def __init__(self, override=False):
        #Initialize Super Class
        UIResponder.__init__(self)
        
        if not override:
            #Initialize __internalObject__
            self.__internalObject__ = __internalObjects__.UIView.alloc()
        
    def initWithFrame(self, rect=((0,0),(20,5))): #((x,y),(w,h))
        """
        summary:
            Initializes and returns a newly allocated view object with the specified frame rectangle.
        """        
        self.__internalObject__.initWithFrame(rect)        

class UITabBarItem(UIBarItem):
    """
    summary:
        The UITabBarItem class implements an item on a tab bar, instances of the UITabBar class. A tab bar operates 
        strictly in radio mode, where one item is selected at a time-tapping a tab bar item toggles the view above the 
        tab bar. You can also specify a badge value on the tab bar item for adding additional visual information-for 
        example, the Phone application uses a badge on the item to show the number of new messages. This class also 
        provides a number of system defaults for creating items.

        Use the initWithTabBarSystemItem:tag: method to create one of the system items. Use the 
        initWithTitle:image:tag: method to create a custom item with the specified title and image. 
        
    see:
        http://developer.apple.com/iphone/library/documentation/UIKit/Reference/UITabBarItem_Class/Reference/Reference.html
    """
    def __init__(self):
        #Initialize Super Class
        UIBarItem.__init__(self)

class UIBarButtonItem(UIBarItem):
    """
    summary:
        The UIBarButtonItem class encapsulates the properties and behaviors of items added to UIToolbar and UINavigationBar 
        objects. It inherits basic button behavior from its parent class. This class defines additional initialization 
        methods and properties for use on tab bars and navigation bars that allow more custom views. 
        
    see:
        http://developer.apple.com/iphone/library/documentation/UIKit/Reference/UIBarButtonItem_Class/Reference/Reference.html
    """
    def __init__(self):
        #Initialize Super Class
        UIBarItem.__init__(self)

class UITabBarController(UIViewController):
    """
    summary:
        The UITabBarController class implements a controller that manages all aspects of a radio interface using a tab bar. 
        It uses view controllers, instances of UIViewController supplied by the application, to configure the items and 
        display views. Each view controller provides information on how to set up an item and supplies the view to be 
        displayed when that item is selected. A tab bar controller manages a set of view controllers much as a tab bar 
        manages items. Although a tab bar controller uses a tab bar in its implementation, you should never need to, 
        nor should you, access the tab bar directly.

        After you create a tab bar controller, you set its view controllers using the viewControllers property. Also set 
        the initial selection for radio interfaces using the selectedViewController property. You should then attach a 
        tab bar controller\'s view to a window to display the tab bar. The tab bar controller displays the selected view 
        above the tab bar.

        You configure the appearance of the tab bar by setting the properties of the view controllers you add to the tab 
        bar controller. At a minimum, a view controller added to a tab bar controller should have the title and view 
        properties set. Use the tabBarItem property to specify the appearance of the view controller.

        The tab bar controller also resizes and positions your views between the tab bar and a navigation bar (if present); 
        otherwise, between the tab bar and status bar. Therefore, set the autoresizingMask properties of your views so 
        they are resized appropriately when displayed by the tab bar controller.

        If you add more items than can be displayed by a tab bar, a More item automatically appears at the end of the 
        tab bar. When the user taps the More item, a More view appears listing the items that don\'t fit on the tab bar. 
        The user can select the items by tapping them in the list. If the customizableViewControllers property is not nil, 
        then an Edit button also appears on the More view allowing the user to customize the tab bar.

        If you want to augment the behavior of customizing a tab bar (the user interface for adding, replacing, and 
        removing items from a tab bar), set the delegate property to an object conforming to the 
        UITabBarControllerDelegate protocol and implement the delegate methods accordingly.

        This class is not intended to be subclassed.

    see:
        http://developer.apple.com/iphone/library/documentation/UIKit/Reference/UITabBarController_Class/Reference/Reference.html
    """
    def __init__(self):
        #Initialize Super Class
        UIViewController.__init__(self)

class UITableViewController(UIViewController):
    """
    summary:
        The UITableViewController class creates a controller object that manages a table view. It implements the following 
        behavior:

        -If a nib file is specified via the initWithNibName:bundle: method (which is declared by the superclass 
        UIViewController), UITableViewController loads the table view archived in the nib file. Otherwise, it creates an 
        unconfigured UITableView object with the correct dimensions and autoresize mask. You can access this view 
        through the tableView property.

        -If a nib file containing the table view is loaded, the data source and delegate become those objects defined in 
        the nib file (if any). If no nib file is specified or if the nib file defines no data source or delegate, 
        UITableViewController sets the data source and the delegate of the table view to self.

        -When the table view is about to appear, it reloads its data and clears its selection (with or without animation, 
        depending on the request). The UITableViewController class implements this in the superclass method 
        viewWillAppear:.

        -When the table view has appeared, the controller flashes the table view\'s scroll indicators. The 
        UITableViewController class implements this in the superclass method viewDidAppear:.

        -It implements the superclass method setEditing:animated: so that if a user taps an Edit|Done button in the 
        navigation bar, the controller toggles the edit mode of the table.

        You create a custom subclass of UITableViewController for each table view that you want to manage. When you 
        initialize the controller in initWithStyle:, you must specify the style of the table view (plain or grouped) 
        that the controller is to manage. Because the initially created table view is without table dimensions 
        (that is, number of sections and number of rows per section) or content, the table view\'s data source and 
        delegate-that is, the UITableViewController object itself-must provide the table dimensions, the cell 
        content, and any desired configurations (as usual). You may override loadView or any other superclass method, 
        but if you do be sure to invoke the superclass implementation of the method, usually as the first method call.

    see:
        http://developer.apple.com/iphone/library/documentation/UIKit/Reference/UITableViewController_Class/Reference/Reference.html
    """
    def __init__(self):
        #Initialize Super Class
        UIViewController.__init__(self)

class UINavigationController(UIViewController):
    """
    summary:
        The UINavigationController class implements a specialized controller for a navigation bar that manages all aspects 
        of drilling down a hierarchy of objects. It uses application-supplied view controllers to configure the 
        navigation bar and display views below it. Each view controller has a navigation item that provides information 
        on how to set the navigation bar left, middle, and right views. 

        A navigation controller manages a stack of view controllers much as a navigation bar managing navigation bar 
        items. You push and pop view controllers onto a navigation controller. 

        Since the UINavigationController class inherits from the UIViewController class, its instances also have a 
        view property. A navigation controller\'s view contains a navigation bar and its top view controller\'s view in 
        its hierarchy. Therefore, you just need to attach the navigation controller\'s view to a window to display it.

        Although, navigation controller uses a navigation bar in its implementation, you should never need to, nor 
        should you, access the navigation bar directly. You can, however, access the navigation items that represent 
        the appearance of your view controllers.

        You can also add navigation controllers to a toolbar controller. And even, present a navigation controller as 
        a modal view on top of another view controller. In this case, the top view controller\'s view is displayed when 
        the navigation controller is presented to the user, and its navigation bar covers any existing navigation bars.

        When you pop and push view controllers, the navigation controller updates the navigation bar and view 
        appropriately. At a minimum, the view controller sets the title and view properties.

        The view should be a resizable view that can be attached to any view hierarchy. The navigation controller 
        resizes and positions your views depending on where the navigation bar is and whether a toolbar is displayed. 
        Therefore, set the autoresizingMask properties of your views so they are resized appropriately when displayed 
        by the navigation controller.

        This class is not intended to be subclassed.

    see:
        http://developer.apple.com/iphone/library/documentation/UIKit/Reference/UINavigationController_Class/Reference/Reference.html
    """
    def __init__(self):
        #Initialize Super Class
        UIViewController.__init__(self)

class UIWindow(UIView):
    """
    summary:
        The UIWindow class defines objects (known as windows ) that manage and coordinate the windows an application 
        displays on the screen. The two principal functions of a window are to provide an area for displaying its views 
        and to distribute events to the views. The window is the root view in the view hierarchy. A window belongs to a 
        level; the windows in one level appear above another level. For example, alerts appear above normal windows. 
        Typically, there is only one window in an iPhone OS application.
        
    see:
        http://developer.apple.com/iphone/library/documentation/UIKit/Reference/UIWindow_Class/UIWindowClassReference/UIWindowClassReference.html
    """
    def __init__(self):
        #Initialize Super Class
        UIView.__init__(self, override=True)

class UILabel(UIView):
    """
    summary:
        The UILabel class implements a read-only text view. You can use this class to draw one or multiple lines of static 
        text, such as those you might use to identify other parts of your user interface. The base UILabel class provides 
        control over the appearance of your text, including whether it uses a shadow or draws with a highlight. If needed, 
        you can customize the appearance of your text further by subclassing. 

        The default content mode of the UILabel class is UIViewContentModeRedraw. This mode causes the view to redraw its 
        contents every time its bounding rectangle changes. You can change this mode by modifying the inherited contentMode 
        property of the class.

        New label objects are configured to disregard user events by default. If you want to handle events in a custom 
        subclass of UILabel, you must explicitly change the value of the userInteractionEnabled property to YES after 
        initializing the object. 

    see:
        http://developer.apple.com/iphone/library/documentation/UIKit/Reference/UILabel_Class/Reference/UILabel.html
    """
    def __init__(self):
        #Initialize Super Class
        UIView.__init__(self, override=True)

class UIPickerView(UIView):
    """
    summary:
        The UIPickerView class implements objects that use a spinning-wheel or slot-machine motif to show one or more 
        sets of values. Users select values by rotating the wheels until a row of values is aligned with a selection 
        indicator. 

        The UIDatePicker class uses a custom subclass of UIPickerView to display dates and times. To see an example, 
        tap the add (\"+\") button in the the Alarm pane of the Clock application.

        A UIPickerView object is a potentially multidimensional user-interface element consisting of rows and components. 
        A component is a wheel, which has a series of items (rows) at indexed locations on the wheel. Each component 
        also has an indexed location (left to right) in a picker view. Each row on a component has content, which is 
        either a string or a view object such as a label (UILabel) or an image (UIImageView). 

        A UIPickerView object requires the cooperation of a delegate for constructing its components and a data source 
        for providing the number of rows and components. The delegate must adopt the UIPickerViewDelegate protocol and 
        implement the required methods to return the drawing rectangle for rows in each component. It also provides the 
        content for each component\'s row, either as a string or a view, and it typically responds to new selections or 
        deselections. The data source must adopt the UIPickerViewDataSource protocol and implement the required methods 
        to return number of components and the number of rows in each component. 

        You can dynamically change the rows of one or all components by calling the reloadComponent: or 
        reloadAllComponents methods, respectively. These methods cause UIPickerView to request the delegate to provide 
        new component and row data. You reload a picker view when a selected value in one component changes the set of 
        values in another component; for example, changing a row value from February to March in one component would 
        change a related component representing the days of the month.

    see:
        http://developer.apple.com/iphone/library/documentation/UIKit/Reference/UIPickerView_Class/Reference/UIPickerView.html
    """
    def __init__(self):
        #Initialize Super Class
        UIView.__init__(self, override=True)

class UIProgressView(UIView):
    """
    summary:
        You use the UIProgressView class to depict the progress of a task over time. An example of a progress bar is 
        the one shown at the bottom of the Mail application when it\'s downloading messages.

        The UIProgressView class provides properties for managing the style of the progress bar and for getting and 
        setting values that are pinned to the progress of a task.

        For an indeterminate progress indicator-or, informally, a \"spinner\"-use an instance of the UIActivityIndicatorView 
        class.

    see:
        http://developer.apple.com/iphone/library/documentation/UIKit/Reference/UIProgressView_Class/Reference/Reference.html
    """
    def __init__(self):
        #Initialize Super Class
        UIView.__init__(self, override=True)

class UIActivityIndicatorView(UIView):
    """
    summary:
        The UIActivityIndicatorView class creates and manages an indicator showing the indeterminate progress of a task. 
        Visually, this indicator is a \"gear\" that is animated to spin.

        You control when the progress indicator animates with the startAnimating and stopAnimating methods. 
        If the hidesWhenStopped property is set to YES, the indicator is automatically hidden when animation stops.

    see:
        http://developer.apple.com/iphone/library/documentation/UIKit/Reference/UIActivityIndicatorView_Class/Reference/UIActivityIndicatorView.html
    """
    def __init__(self):
        #Initialize Super Class
        UIView.__init__(self, override=True)

class UIImageView(UIView):
    """
    summary:
        An image view object provides a view-based container for displaying either a single image or for animating a 
        series of images. For animating the images, the UIImageView class provides controls to set the duration and 
        frequency of the animation. You can also start and stop the animation freely. 

        New image view objects are configured to disregard user events by default. If you want to handle events in a 
        custom subclass of UIImageView, you must explicitly change the value of the userInteractionEnabled property to 
        YES after initializing the object. 

    see:
        http://developer.apple.com/iphone/library/documentation/UIKit/Reference/UIImageView_Class/Reference/Reference.html
    """
    def __init__(self):
        #Initialize Super Class
        UIView.__init__(self, override=True)

class UITabBar(UIView):
    """
    summary:
        The UITabBar class implements a control for selecting one of two or more buttons, called items. The most common 
        use of a tab bar is to implement a modal interface where tapping an item changes the selection. Use a UIToolbar 
        object if you want to momentarily highlight or not change the appearance of an item when tapped. The UITabBar 
        class provides the ability for the user to customize the tab bar by reordering, removing, and adding items to the 
        bar. You can use a tab bar delegate to augment this behavior.

        Use the UITabBarItem class to create items and the setItems:animated: method to add them to a tab bar. 
        All methods with an animated: argument allow you to optionally animate changes to the display. Use the 
        selectedItem property to access the current item.

    see:
        http://developer.apple.com/iphone/library/documentation/UIKit/Reference/UITabBar_Class/Reference/Reference.html
    """
    def __init__(self):
        #Initialize Super Class
        UIView.__init__(self, override=True)

class UIToolbar(UIView):
    """
    summary:
        The UIToolbar class implements a control for selecting one of many buttons, called toolbar items. A toolbar 
        momentarily highlights or does not change the appearance of an item when tapped. Use the UITabBar class if you 
        need a radio button style control. 

        Use the UIBarButtonItem class to create items and the setItems:animated: method to add them to a toolbar. 
        All methods with an animated: argument allow you to optionally animate changes to the display.

        Note that the images used on the toolbar to represent the normal and highlighted states of an item are derived 
        from the image you set using the inherited image property in UIBarItem. For example, the image is converted to 
        white and then bevelled by adding a shadow for the normal state.

    see:
        http://developer.apple.com/iphone/library/documentation/UIKit/Reference/UIToolbar_Class/Reference/Reference.html
    """
    def __init__(self):
        #Initialize Super Class
        UIView.__init__(self, override=True)

class UINavigationBar(UIView):
    """
    summary:
        The UINavigationBar class implements a control for navigating hierarchical content. It\'s a bar, typically 
        displayed at the top of the screen, containing buttons for navigating up and down a hierarchy. The primary 
        properties are a left (back) button, a center title, and an optional right button. You can specify custom views 
        for each of these.

        The navigation bar represents only the bar at the top of the screen, not the view below. The view below the 
        navigation bar usually lists children or properties of an object represented by the center title. For example, 
        the user selects an object from a list to drill down in the hierarchy or see more details. It\'s the application\'s 
        responsibility to implement this part of the behavior.

        You create a navigation bar using the alloc and init methods. You then can specify the appearance using the 
        barStyle property.

        A UINavigationBar object uses a stack to manage navigation items (instances of UINavigationItem) that represent 
        a state of the navigation bar. You change the navigation bar by pushing navigation items using the 
        pushNavigationItem:animated: method or popping navigation items using the popNavigationItemAnimated: method. 
        Methods with an animated: argument allow you to animate the changes to the display. 

        You can also set items directly using the items property, get the current item using the topItem property, and 
        get the previous item using the backItem property.

        You should set the delegate property to an object conforming to the UINavigationBarDelegate protocol. It is the 
        responsibility of the delegate to update other views when items are pushed or popped from the stack-for example, 
        it should display the previous view when the user clicks the back button.

        Use the UIBarButtonItem class to create custom buttons for navigation items. Read UINavigationItem Class 
        Reference for how to set custom views for the left, center, and right sides of a navigation bar.

    see:
        http://developer.apple.com/iphone/library/documentation/UIKit/Reference/UINavigationBar_Class/Reference/UINavigationBar.html
    """
    def __init__(self):
        #Initialize Super Class
        UIView.__init__(self, override=True)

class UITableViewCell(UIView):
    """
    summary:
        The UITableViewCell class defines the attributes and behavior of the cells that appear in UITableView objects.

        A UITableViewCell object (or table cell) includes properties and methods for managing selected state, editing 
        state and controls, accessory views, reordering controls, cell background, and content indentation. There are 
        also properties for associating target objects and action selectors with detail disclosure buttons. The class 
        additionally includes properties for setting and managing cell content, specifically text and images.

        You have two ways of extending the standard UITableViewCell object. To create cells with multiple, variously 
        formatted and sized strings and images for content, you can get the cell\'s content view (through its contentView 
        property) and add subviews to it. You can also subclass UITableViewCell to obtain cell characteristics and 
        behavior specific to your application\'s needs. See \"A Closer Look at Table-View Cells\" in Table View Programming 
        Guide for iPhone OS for details.

    see:
        http://developer.apple.com/iphone/library/documentation/UIKit/Reference/UITableViewCell_Class/Reference/Reference.html
    """
    def __init__(self):
        #Initialize Super Class
        UIView.__init__(self, override=True)

class UIActionSheet(UIView):
    """
    summary:
        Use the UIActionSheet class to implement an action sheet that displays a message and presents buttons that let 
        the user decide how to proceed. An action sheet is similar in function but differs in appearance from an alert 
        view.

        Use the properties and methods in this class to set the message, set the style, set the delegate, configure 
        the buttons, and display the action sheet. You must set a delegate if you add custom buttons. The delegate 
        should conform to the UIActionSheetDelegate protocol. When you display an action sheet, you can optionally 
        animate it from the bottom bar or an arbitrary view. How the action sheet is animated depends on the bar 
        style or the action sheet style you set.

    see:
        http://developer.apple.com/iphone/library/documentation/UIKit/Reference/UIActionSheet_Class/Reference/Reference.html
    """
    def __init__(self):
        #Initialize Super Class
        UIView.__init__(self, override=True)

class UIAlertView(UIView):    
    """
    summary: 
        Use the UIAlertView class to display an alert message to the user. An alert view functions similar to but differs 
        in appearance from an action sheet (an instance of UIActionSheet).

        Use the properties and methods defined in this class to set the title, message, and delegate of an alert view 
        and configure the buttons. You must set a delegate if you add custom buttons. The delegate should conform to 
        the UIAlertViewDelegate protocol. Use the show method to display an alert view once it is configured.
        
    see: 
        http://developer.apple.com/iphone/library/documentation/UIKit/Reference/UIAlertView_Class/UIAlertView/UIAlertView.html
    """    
    
    def __init__(self):
        """
        summary: 
            Initializes the UIAlertView.
        """
        #Initialize Super Class
        UIView.__init__(self, override=True)
        
        #Initialize __internalObject__
        self.__internalObject__ = __internalObjects__.UIAlertView.alloc()
        
    def initWithTitle(self, title, message, delegate=None, cancelButtonTitle="Cancel", otherButtonTitles=None):
        """
        summary: 
            Convenience method for initializing an alert view.
            
        @param title:
            The string that appears in the receiver's title bar
            
        @param message:
            Descriptive text that provides more details than the title.

        @param delegate:
            The receiver's delegate or None if it doesn't have a delegate.
            
        @param cancelButtonTitle:
            The title of the cancel button or None if there is no cancel button. 
            Using this argument is equivalent to setting the cancel button index to the value 
            returned by invoking addButtonWithTitle: specifying this title. 

        @param otherButtonTitles:
            A tuple containing titles for more buttons to add to the receiver.
            Using this argument is equivalent to invoking addButtonWithTitle: with this title to add more buttons.

        @type title:
            String
            
        @type message:
            String
            
        @type delegate:
            Function
        
        @type cancelButtonTitle:
            String
            
        @type otherButtonTitles:
            Tuple <String>
            
        @return: 
            Newly initialized alert view.
        """
        if not otherButtonTitles:            
            self.__internalObject__.initWithTitle_message_delegate_cancelButtonTitle_otherButtonTitles_(title, message, delegate, cancelButtonTitle, None)
        else:
            self.__internalObject__.initWithTitle_message_delegate_cancelButtonTitle_otherButtonTitles_(title, message, delegate, cancelButtonTitle, *otherButtonTitles)

    def dismissWithClickedButtonIndex(self, buttonIndex, animated):
        """
        summary: 
            Dismisses the receiver, optionally with animation.

        @param buttonIndex:
            The index of the button that was clicked just before invoking this method. The button indices start at 0.
            
        @param animated:
            YES if the receiver should be removed by animating it first; otherwise, NO if it should be removed immediately with no animation.
            Values can be objc.YES and objc.NO!

        @type buttonIndex:
            Integer
            
        @type animated:
            Objective C Boolean (objc.YES or objc.NO)
        """
        self.__internalObject__.dismissWithClickedButtonIndex_animated_(buttonIndex, animated)
        
    def show(self):        
        """
        summary:
            Displays the receiver using animation.
        """        
        self.__internalObject__.show()
        
class UIScrollView(UIView):
    """
    summary:
        UIScrollView is the base class for any class that needs to display content that is larger than the size of the 
        application\'s window. It enables users to scroll within that content by making swiping gestures, and to zoom in 
        and back from portions of the content by making pinching gestures.

        UIScrollView is the superclass of several UIKit classes including UITableView and UITextView.

        The central notion of a UIScrollView object (or, simply, a scroll view) is that it is a view whose origin 
        is adjustable over the content view. It clips the content to its frame, which generally (but not necessarily) 
        coincides that of the application\'s main window. A scroll view tracks the movements of fingers and adjusts the 
        origin accordingly. The view that is showing its content \"through\" the scroll view draws that portion of 
        itself based on the new origin, which is pinned to an offset in the content view. The scroll view itself does 
        no drawing except for displaying vertical and horizontal scroll indicators. The scroll view must know the size 
        of the content view so it knows when to stop scrolling; by default, it \"bounces\" back when scrolling exceeds 
        the bounds of the content.

        The object that manages the drawing of content displayed in a scroll view should tile the content\'s subviews so 
        that no view exceeds the size of the screen. As users scroll in the scroll view, this object should add and 
        remove subviews as necessary.

        Because a scroll view has no scroll bars, it must know whether a touch signals an intent to scroll versus an 
        intent to track a subview in the content. To make this determination, it temporarily intercepts a touch-down 
        event by starting a timer and, before the timer fires, seeing if the touching finger makes any movement. If 
        the time fires without a significant change in position, the scroll view sends tracking events to the touched 
        subview of the content view. If the user then drags his or her finger far enough before the timer elapses, the 
        scroll view cancels any tracking in the subview and performs the scrolling itself. Subclasses can override the 
        touchesShouldBegin:withEvent:inContentView:, pagingEnabled, and touchesShouldCancelInContentView: methods 
        (which are called by the scroll view) to affect how the scroll view handles scrolling gestures.

        A scroll view also handles zooming and panning of content. As the user makes a pinch-in or pinch-out gesture, 
        the scroll view adjusts the offset and the scale of the content. When the gesture ends, the object managing the 
        content view should should update subviews of the content as necessary. (Note that the gesture can end and a 
        finger could still be down.) While the gesture is in progress, the scroll view does not send any tracking calls 
        to the subview. 

        The UIScrollView class can have a delegate that must adopt the UIScrollViewDelegate protocol. For zooming and 
        panning to work, the delegate must implement both viewForZoomingInScrollView: and 
        scrollViewDidEndZooming:withView:atScale:; in addition, the maximum (maximumZoomScale) and minimum 
        ( minimumZoomScale) zoom scale must be different. 

    see:
        http://developer.apple.com/iphone/library/documentation/UIKit/Reference/UIScrollView_Class/Reference/UIScrollView.html
    """
    def __init__(self):
        #Initialize Super Class
        UIView.__init__(self, override=True)

class UISearchBar(UIView):
    """
    summary:
        The UISearchBar class implements a text field control for text-based searches. The control provides a text field 
        for entering text, a search button, a bookmark button, and a cancel button. You use a delegate, an object 
        conforming to the UISearchBarDelegate protocol, to implement the actions when text is entered and buttons are 
        clicked. The UISearchBar object does not actually perform any searches.
        
    see:
        http://developer.apple.com/iphone/library/documentation/UIKit/Reference/UISearchBar_Class/Reference/Reference.html
    """
    def __init__(self):
        #Initialize Super Class
        UIView.__init__(self, override=True)

class UIWebView(UIView):
    """
    summary:
        You use the UIWebView class to embed web content in your application. To do so, you simply create a UIWebView 
        object, attach it to a window, and send it a request to load web content. You can also use this class to move 
        back and forward in the history of webpages, and you can even set some web content properties programmatically.

        Use the loadRequest: method to begin loading web content, the stopLoading method to stop loading, and the loading 
        property to find out if a web view is in the process of loading.

        If you allow the user to move back and forward through the webpage history, then you can use the goBack and 
        goForward methods as actions for buttons. Use the canGoBack and canGoForward properties to disable the buttons 
        when the user can\'t move in a direction.

        By default, a web view automatically converts telephone numbers that appear in web content to Phone links. 
        When a Phone link is tapped, the Phone application launches and dials the number. Set the detectsPhoneNumbers 
        property to NO to turn off this default behavior.

        You can also use the request property to programmatically set the scale of web content the first time it is 
        displayed in a web view. Thereafter, the user can change the scale using gestures.

        Set the delegate property to an object conforming to the UIWebViewDelegate protocol if you want to track the 
        loading of web content.

        Read Safari Web Content Guide for iPhone OS for how to create web content that is compatible with and optimized 
        for displaying in Safari on iPhone and your web views.

    see:
        http://developer.apple.com/iphone/library/documentation/UIKit/Reference/UIWebView_Class/Reference/Reference.html
    """
    def __init__(self):
        #Initialize Super Class
        UIView.__init__(self, override=True)

class UIControl(UIView):
    """
    summary:
        UIControl is the base class for controls: objects such as buttons and sliders that are used to convey user intent 
        to the application. You cannot use UIControl directly to instantiate controls. It instead defines the common 
        interface and behavioral structure for all subclasses of it. 

        The main role of UIControl is to define an interface and base implementation for preparing action messages and 
        initially dispatching them to their targets when specified events occur. (See \"The Target-Action Mechanism\" for 
        an overview.) It also includes methods for getting and setting control state (for example, for determining 
        whether a control is enabled or highlighted) and it defines methods for tracking touches within a control 
        (the latter group of methods are for overriding by subclasses).

    see:
        http://developer.apple.com/iphone/library/documentation/UIKit/Reference/UIControl_Class/Reference/Reference.html
    """
    def __init__(self):
        #Initialize Super Class
        UIView.__init__(self, override=True)

class UIImagePickerController(UINavigationController):
    """
    summary:
        The UIImagePickerController class manages the system-supplied user interfaces for choosing and taking pictures. 
        You use this class in situations where you want to obtain a picture from the user. The class manages the actual 
        user interactions with the views and reports the results of those interactions to your delegate object.

        Because the UIImagePickerController class handles all of the user interactions, all you have to do is tell 
        it which user interface to display, tell it to start, and then dismiss it when the user picks an image or 
        cancels. Before starting an interface, however, you should always verify that the interface is supported by 
        the current device by calling the isSourceTypeAvailable: class method. 

        You must provide a delegate that conforms to the UIImagePickerControllerDelegate protocol in order to use this 
        class. After the interface starts, this class notifies your delegate of the user\'s actions. Your delegate is 
        then responsible for dismissing the picker and returning to your application\'s views. 

    see:
        http://developer.apple.com/iphone/library/documentation/UIKit/Reference/UIImagePickerController_Class/UIImagePickerController/UIImagePickerController.html
    """
    def __init__(self):
        #Initialize Super Class
        UINavigationController.__init__(self)

class UITableView(UIScrollView):
    """
    summary:
        An instance of UITableView (or simply, a table view) is a means for displaying and editing hierarchical lists of 
        information.

        A table view in the UIKit framework is limited to a single column because it is designed for a device with a 
        small screen. UITableView is a subclass of UIScrollView, which allows users to scroll through the table, although 
        UITableView allows vertical scrolling only. The cells comprising the individual items of the table are 
        UITableViewCell objects; UITableView uses these objects to draw the visible rows of the table. Cells have 
        content-titles and images-and can have, near the right edge, accessory views. Standard accessory views are 
        disclosure indicators or detail disclosure buttons; the former leads to the next level in a data hierarchy and 
        the latter leads to a detailed view of a selected item. Accessory views can also be framework controls, such as 
        switches and sliders, or can be custom views. Table views can enter an editing mode where users can insert, 
        delete, and reorder rows of the table. 

        A table view is made up of one or more sections, each with its own rows. Sections are identified by their index 
        number within the table view, and rows are identified by their index number within a section. Any section can 
        optionally be preceded by a section header, and optionally be followed by a section footer. 

        Table views can have one of two styles, UITableViewStylePlain and UITableViewStyleGrouped. When you create a 
        UITableView instance you must specify a table style, and this style cannot be changed. In the plain style, 
        section headers and footers float above the content if the part of a complete section is visible. A table view 
        can have an index that appears as a bar on the right hand side of the table (for example, "a" through "z"). 
        You can touch a particular label to jump to the target section. The grouped style of table view provides a 
        default background color and a default background view for all cells. The background view provides a visual 
        grouping for all cells in a particular section. For example, one group could be a person's name and title, 
        another group for phone numbers that the person uses, and another group for email accounts and so on. See the 
        Settings application for examples of grouped tables. Table views in the grouped style cannot have an index.

        Many methods of UITableView take NSIndexPath objects as parameters and return values. UITableView declares a 
        category on NSIndexPath that enables you to get the represented row index (row property) and section index 
        (section property), and to construct an index path from a given row index and section index 
        (indexPathForRow:inSection: method). Especially in table views with multiple sections, you must evaluate the 
        section index before identifying a row by its index number. 

        A UITableView object must have an object that acts as a data source and and object that acts as a delegate; 
        typically these objects are either the application delegate or, more frequently, a custom UITableViewController 
        object. The data source must adopt the UITableViewDataSource protocol and the delegate must adopt the 
        UITableViewDelegate protocol. The data source provides information that UITableView needs to construct tables 
        and manages the data model when rows of a table are inserted, deleted, or reordered. The delegate provides the 
        cells used by tables and performs other tasks, such as managing accessory views and selections.

        When sent a setEditing:animated: message (with a first parameter of YES), the table view enters into editing 
        mode where it shows the editing or reordering controls of each visible row, depending on the editingStyle of 
        each associated UITableViewCell. Clicking on the insertion or deletion control causes the data source to receive 
        a tableView:commitEditingStyle:forRowAtIndexPath: message. You commit a deletion or insertion by calling 
        deleteRowsAtIndexPaths:withRowAnimation: or insertRowsAtIndexPaths:withRowAnimation:, as appropriate. Also 
        in editing mode, if a table-view cell has its showsReorderControl property set to YES, the data source 
        receives a tableView:moveRowAtIndexPath:toIndexPath: message. The data source can selectively remove the 
        reordering control for cells by implementing tableView:canMoveRowAtIndexPath:. 

        UITableView caches table-view cells only for visible rows, but caches row, header, and footer heights for the 
        entire table. You can create custom UITableViewCell objects with content or behavioral characteristics that 
        are different than the default cells; \"A Closer Look at Table-View Cells" in Table View Programming Guide for 
        iPhone OS explains how.

    see:
        http://developer.apple.com/iphone/library/documentation/UIKit/Reference/UITableView_Class/Reference/Reference.html
    """
    def __init__(self):
        #Initialize Super Class
        UIScrollView.__init__(self)

class UITextView(UIScrollView):
    """
    summary:
        The UITextView class implements the behavior for a scrollable, multiline text region. The class supports the 
        display of text using a custom font, color, and alignment and also supports text editing. You typically use a 
        text view to display multiple lines of text, such as when displaying the body of a large text document. 

        This class does not support multiple styles for text. The font, color, and text alignment attributes you specify 
        always apply to the entire contents of the text view. To display more complex styling in your application, 
        you need to use a UIWebView object and render your content using HTML. 

    see:
        http://developer.apple.com/iphone/library/documentation/UIKit/Reference/UITextView_Class/Reference/UITextView.html
    """
    def __init__(self):
        #Initialize Super Class
        UIScrollView.__init__(self)

class UIButton(UIControl):
    """
    summary:
        The UIButton class is a UIControl subclass that implements a button on the touch screen. A button intercepts 
        touch events and sends an action message to a target object when it\'s tapped. Methods for setting the target 
        and action are inherited from UIControl. This class provides methods for setting the title, image, and other 
        appearance properties of a button. By using the set methods, you can specify a different appearance for each 
        button state.
        
    see:
        http://developer.apple.com/iphone/library/documentation/UIKit/Reference/UIButton_Class/UIButton/UIButton.html
    """
    def __init__(self):
        #Initialize Super Class
        UIControl.__init__(self)

class UIDatePicker(UIControl):
    """
    summary:
        The UIDatePicker class implements an object that uses multiple rotating wheels to allow users to select dates 
        and times. iPhone examples of a date picker are the Timer and Alarm (Set Alarm) panes of the Clock application. 
        You may also use a date picker as a countdown timer.

        When properly configured, a UIDatePicker object sends an action message when a user finishes rotating one of 
        the wheels to change the date or time; the associated control event is UIControlEventValueChanged. A 
        UIDatePicker object presents the countdown timer but does not implement it; the application must set up an 
        NSTimer object and update the seconds as they\'re counted down. 

        UIDatePicker does not inherit from UIPickerView, but it manages a custom picker-view object as a subview.

    see:
        http://developer.apple.com/iphone/library/documentation/UIKit/Reference/UIDatePicker_Class/Reference/UIDatePicker.html
    """
    def __init__(self):
        #Initialize Super Class
        UIControl.__init__(self)

class UIPageControl(UIControl):
    """
    summary:
        You use the UIPageControl class to create and manage page controls. A page control is a succession of dots 
        centered in the control. Each dot corresponds to a page in the application\'s document (or other data-model entity),
         with the white dot indicating the currently viewed page. 

        For an example of a page control, see the Weather application (with a number of locations configured) or 
        Safari (with a number of tab views set).

        When a user taps a page control to move to the next or previous page, the control sends the 
        UIControlEventValueChanged event for handling by the delegate. The delegate can then evaluate the currentPage 
        property to determine the page to display. The page control advances only one page in either direction.

        Note: Because of physical factors-namely the size of the device screen and the size and layout of the page 
        indicators-there is a limit of about 20 page indicators on the screen before they are clipped.

    see:
        http://developer.apple.com/iphone/library/documentation/UIKit/Reference/UIPageControl_Class/Reference/Reference.html
    """
    def __init__(self):
        #Initialize Super Class
        UIControl.__init__(self)

class UISegmentedControl(UIControl):
    """
    summary:
        A UISegmentedControl object is a horizontal control made of multiple segments, each segment functioning as a 
        discrete button. A segmented control affords a compact means to group together a number of controls.

        A segmented control can display a title (an NSString object) or an image (UIImage object). The UISegmentedControl 
        object automatically resizes segments to fit proportionally within their superview unless they have a specific 
        width set. When you add and remove segments, you can request that the action be animated with sliding and fading 
        effects.

        How you configure a segmented control can affect its display behavior:
        
        -If you set a segmented control to have a momentary style, a segment doesn\'t show itself as selected 
        (blue background) when the user touches it. The disclosure button is always momentary and doesn\'t affect 
        the actual selection. 

        -If a segmented control has only two segments, then it behaves like a switch-tapping the currently-selected 
        segment causes the other segment to be selected.

    see:
        http://developer.apple.com/iphone/library/documentation/UIKit/Reference/UISegmentedControl_Class/Reference/UISegmentedControl.html
    """
    def __init__(self):
        #Initialize Super Class
        UIControl.__init__(self)

class UITextField(UIControl):
    """
    summary:
        A UITextField object is a control that displays editable text and sends an action message to a target object 
        when the user presses the return button. You typically use this class to gather small amounts of text from the 
        user and perform some immediate action, such as a search operation, based on that text. 

        In addition to its basic text-editing behavior, the UITextField class supports the use of overlay views to 
        display additional information (and provide additional command targets) inside the text field boundaries. 
        You can use custom overlay views to display features such as a bookmarks button or search icon. The UITextField 
        class also provides a built-in button for clearing the current text. 

        A text field object supports the use of a delegate object to handle editing-related notifications. You can use 
        this delegate to customize the editing behavior of the control and provide guidance for when certain actions 
        should occur. For more information on the methods supported by the delegate, see the UITextFieldDelegate 
        protocol. 
        
    see:
        http://developer.apple.com/iphone/library/documentation/UIKit/Reference/UITextField_Class/Reference/UITextField.html
    """
    def __init__(self):
        #Initialize Super Class
        UIControl.__init__(self)

class UISlider(UIControl):
    """
    summary:
        A UISlider object is a visual control used to select a single value from a continuous range of values. 
        Sliders are always displayed as horizontal bars. An indicator, or thumb, notes the current value of the 
        slider and can be moved by the user to change the setting.
        
    see:
        http://developer.apple.com/iphone/library/documentation/UIKit/Reference/UISlider_Class/Reference/Reference.html
    """
    def __init__(self):
        #Initialize Super Class
        UIControl.__init__(self)

class UISwitch(UIControl):
    """
    summary:
        You use the UISwitch class to create and manage the On/Off buttons you see, for example, in the preferences 
        (Settings) for such services as Airplane Mode. These objects are known as switches. 

        The UISwitch class declares a property and a method to control its on/off state. As with UISlider, 
        when the user manipulates the switch control (\"flips\" it) a UIControlEventValueChanged event is generated, 
        which results in the control (if properly configured) sending an action message.

        The UISwitch class is not customizable.

    see:
        http://developer.apple.com/iphone/library/documentation/UIKit/Reference/UISwitch_Class/Reference/Reference.html    
    """
    def __init__(self):
        #Initialize Super Class
        UIControl.__init__(self)